package com.Algorithm.HUAWEI.four20220505;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: zjz
 * @Date: 2022/05/23/16:07
 * @Description:
 * @Target:
 */
public class 矩阵乘法计算量估算 {
    /*
    * 描述
    矩阵乘法的运算量与矩阵乘法的顺序强相关。
    例如：

    A是一个50×10的矩阵，B是10×20的矩阵，C是20×5的矩阵

    计算A*B*C有两种顺序：((AB)C)或者(A(BC))，前者需要计算15000次乘法，后者只需要3500次。

    编写程序计算不同的计算顺序需要进行的乘法次数。

    数据范围：矩阵个数：1≤n≤15 ，行列数：1 ≤ row_i,col_i ≤ 100，保证给出的字符串表示的计算顺序唯一。
    进阶：时间复杂度：O(n) ，空间复杂度：O(n)

    输入描述：
    输入多行，先输入要计算乘法的矩阵个数n，每个矩阵的行数，列数，总共2n的数，最后输入要计算的法则
    计算的法则为一个字符串，仅由左右括号和大写字母（'A'~'Z'）组成，保证括号是匹配的且输入合法！

    输出描述：
    输出需要进行的乘法次数

    示例1
    输入：
    3
    50 10
    10 20
    20 5
    (A(BC))
    复制
    输出：
    3500

    *
    * */


// 10*20*5 = 1000  50*10*5 = 2500
    // 遇到（入栈，同时字母也入栈，遇到）出栈到一个括号

    // 思路，使用对象来操作，每次操作完，所有值赋予第一个对象，然后就可以了。

/*

public static void main(String[] args) throws IOException {

    // 遇到（是入栈，遇到）是出栈，出到，第二个（为止
    // 每两个对应一个字母
    BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
    int N = Integer.valueOf(in.readLine());

    int [] ints = new int[N*2];
    int p = 0;
    for (int i = 0; i < N; i++) {
        String[] s = in.readLine().split(" ");
        ints[p++] = Integer.valueOf(s[0]);
        ints[p++] = Integer.valueOf(s[1]);
    }

    String ss = in.readLine();
    Stack<Character> queue = new Stack<Character>();


    int Z1 = 0;
    int Z2 = 0;
    char tempChar = 'z';
    int sum = 0;

    for (int i = 0; i < ss.length(); i++) {
        if (ss.charAt(i)=='('){
            queue.add(ss.charAt(i));
        }else if (ss.charAt(i)>='A'&&ss.charAt(i)<='Z'){
            queue.add(ss.charAt(i));
        }else if (ss.charAt(i)==')'){
            int tempNum1 = 0;
            int tempNum2 = 0;
            // 思路：如果到了),那么就弹，如果是字母，就先弹出，设置一个字符串进行统计字符，且新增一个flag。如果
            Character pop = 'A';
            String CharCount = "";
            while (!queue.isEmpty() && (pop = queue.pop()) != '(' ) {
                CharCount += pop;
            }

            for (int j = CharCount.length() -1; j >= 0; j--) {
                int index = CharCount.charAt(j) - 'A';
                if (CharCount.length()==1 && CharCount.charAt(j)!='z'){
                    Z1 = ints[index*2];
                    Z2 = ints[index*2+1];
                    queue.add('z');
                    break;
                }else if (CharCount.length()!=1 && j < CharCount.length()){
                    if (CharCount.charAt(j)!='z'){
                        if (tempNum1==0){
                            tempNum1 = ints[index*2];
                            tempNum2 = ints[index*2+1];
                        }else{
                            sum += tempNum1 * tempNum2 * ints[index*2+1];
                            tempNum1 = tempNum1;
                            Z1 = tempNum1;
                            tempNum2 = ints[index*2+1];
                            Z2 = ints[index*2+1];
                            if (j==0){
                                queue.add('z');
                            }
                        }
                    }else {
                        if (tempNum1==0){
                            tempNum1 = Z1;
                            tempNum2 = Z2;
                        }else{
                            sum += tempNum1 * tempNum2 * Z2;
                            tempNum1 = tempNum1;
                            Z1 = tempNum1;
                            tempNum2 = Z2;
                            if (j==0){
                                queue.add('z');
                            }
                        }

                    }
                }
            }

        }
    }

    System.out.println(sum);

}

*/

    public static void main(String[] args) throws IOException{
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.valueOf(in.readLine());
        Letters[] letters = new Letters[N];
        for (int i = 0; i < N; i++) {
            String[] ss = in.readLine().split(" ");
            letters[i] = new Letters((char) ('A'+i),Integer.valueOf(ss[0]),Integer.valueOf(ss[1]));
        }
        String ss = in.readLine();
        process(ss,letters);
    }

// 进来的是字符串和Letters数组
    static void process(String ss,Letters[] letters){
        Stack<Character> queue = new Stack<Character>();
        int sum = 0;
        for (int i = 0; i < ss.length(); i++) {
            if (ss.charAt(i)=='('){
                queue.add(ss.charAt(i));
            }else if (ss.charAt(i)>='A'&&ss.charAt(i)<='Z'){
                queue.add(ss.charAt(i));
            }else if (ss.charAt(i)==')'){
                // 思路：如果到了),那么就弹，如果是字母，就先弹出，设置一个字符串进行统计字符，且新增一个flag。如果
                Character pop = 'A';
                String CharCount = "";
                while (!queue.isEmpty() && (pop = queue.pop()) != '(' ) {
                    CharCount += pop;
                }

                for (int j = CharCount.length() -1; j >= 0; j--) {
                    int index1 = CharCount.charAt(j) - 'A';
                    if (j >= 1){
                        int index2 = CharCount.charAt(j-1) - 'A';
                        sum += letters[index1].getValue1() * letters[index1].getValue2() * letters[index2].getValue2();
                        letters[index1].setValue2(letters[index2].getValue2());
                        queue.add(letters[index1].getC1());
                        j--;
                    }else {
                        queue.add(CharCount.charAt(j));
                    }
                }

            }
        }
        System.out.println(sum);

    }

    static class Letters{
        private char c1;
        private int value1;
        private int value2;

        public Letters() {
        }

        public Letters(char c1, int value1, int value2) {
            this.c1 = c1;
            this.value1 = value1;
            this.value2 = value2;
        }


        public char getC1() {
            return c1;
        }

        public void setC1(char c1) {
            this.c1 = c1;
        }

        public int getValue1() {
            return value1;
        }

        public void setValue1(int value1) {
            this.value1 = value1;
        }

        public int getValue2() {
            return value2;
        }

        public void setValue2(int value2) {
            this.value2 = value2;
        }


        @Override
        public String toString() {
            return "Letters{" +
                    "c1=" + c1 +
                    ", value1=" + value1 +
                    ", value2=" + value2 +
                    '}';
        }
    }

}
